// 1019.[优先队列]简单负载均衡 https://oj.rnd.huawei.com/problems/1019/details
// 负载分担规则：
// 按顺序循环分配服务器，如：有3台服务器且都空闲，分配的方式为 1->2->3->1… ；
// 如果某台服务器繁忙，则跳过该服务器；
// 如果一条消息到达时所有服务器繁忙，则丢弃这条消息。
// 输出处理负载最多的服务器编号，注意按升序输出。
// 输入
// 3
// 7
// 1 15
// 2 10
// 12 10
// 5 10
// 6 10
// 30 15
// 32 10
// 输出 1 3

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;

struct Message {
  int start;
  int load;
};

class Solution1 {
 public:
  vector<int> FindHighestLoadServers(size_t serverNum,
                                     const vector<Message>& messages) {
    vector<int> result;
    // 维护一个服务器机器字典 loadTotal, No
    map<int, int> resMap;
    vector<Message> srtMsgs(messages.begin(), messages.end());
    // 消息按到达时刻排序
    sort(srtMsgs.begin(), srtMsgs.end(),
         [](Message& a, Message& b) -> bool { return a.start < b.start; });
    int serNo = 1;
    // 记录服务器负载最大值
    int maxSum = 0;
    // 维护一个最小堆优先队列，根节点最小，出队先出最小,
    // pair<int, int>存完成时刻和机器索引号，优先队列按完成时刻排序
    priority_queue<pair<int, int>, vector<pair<int, int> >,
                   greater<pair<int, int> > >
        queServer;
    for (size_t i = 0; i < srtMsgs.size(); ++i) {
      // 队列小于服务器数量时，按照顺序分配机器
      if (queServer.size() < serverNum) {
        queServer.push({srtMsgs[i].start + srtMsgs[i].load, serNo});
        resMap[serNo] += srtMsgs[i].load;
        maxSum = max(maxSum, resMap[serNo]);
        serNo++;
      } else if (queServer.size() == serverNum) {
        //  队列等于服务器数量时，分两种情况
        //  i.当前请求消息到达时刻小于优先队列根节点，代表所有服务器繁忙，则丢弃这条消息
        //  ii.当前请求消息到达时刻大于或等于优先队列根节点，代表优先队列根节点在当前时刻是最早空闲的，可以分配给当前信息
        if (srtMsgs[i].start >= queServer.top().first) {
          int tmpNo = queServer.top().second;
          queServer.pop();
          queServer.push({srtMsgs[i].start + srtMsgs[i].load, tmpNo});
          resMap[tmpNo] += srtMsgs[i].load;
          maxSum = max(maxSum, resMap[tmpNo]);
        }
      }
    }
    for (auto item : resMap) {
      if (item.second == maxSum) {
        result.push_back(item.first);
      }
    }
    sort(result.begin(), result.end());
    return result;
  }
};
inline int ReadInt() {
  int number;
  cin >> number;
  return number;
}
template <typename T>
inline void WriteVector(const vector<T>& objects, char delimeter = ' ') {
  auto it = objects.begin();
  if (it == objects.end()) {
    return;
  }
  cout << *it;
  for (++it; it != objects.end(); ++it) {
    cout << delimeter << *it;
  }
  cout << endl;
}

int main() {
  int serverNum = ReadInt();
  int n = ReadInt();
  vector<Message> msgs;
  for (int i = 0; i < n; ++i) {
    Message obj;
    cin >> obj.start >> obj.load;
    msgs.push_back(obj);
  }
  Solution1 solu;
  vector<int> result = solu.FindHighestLoadServers(serverNum, msgs);
  WriteVector(result, ' ');
  return 0;
}
